package com.dragon.modules.yuegou.query.wallet;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.wallet.EntityCardEntity;
import com.dragon.modules.yuegou.enums.OwnerType;
import com.dragon.modules.yuegou.enums.wallet.EntityCardCardNoRules;
import com.dragon.modules.yuegou.enums.wallet.EntityCardCardPwdRules;
import com.dragon.modules.yuegou.enums.wallet.EntityCardCardStyle;
import com.dragon.modules.yuegou.enums.wallet.EntityCardCheckStatus;
import com.dragon.modules.yuegou.enums.wallet.EntityCardMakeCardWay;
import com.dragon.modules.yuegou.enums.wallet.EntityCardPeriodUnit;
import com.dragon.modules.yuegou.enums.wallet.EntityCardScope;
import com.dragon.modules.yuegou.enums.wallet.EntityCardTimeLimitType;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;

/**
 * 实体卡 动态查询条件
 * 
 * @author pbuilder generated
 * @date 2021-03-25 19:43:27
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class EntityCardQuery extends EntityCardEntity implements Query<EntityCardEntity> {

    /** id查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

    /** 悦卡id查询条件 */
	@JsonUnwrapped(prefix = "cardTemplateId")
	private Condition<String> cardTemplateIdCondition;

    /** 悦卡名称查询条件 */
	@JsonUnwrapped(prefix = "cardTemplateTitle")
	private Condition<String> cardTemplateTitleCondition;

    /** [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件 */
	@JsonUnwrapped(prefix = "ownerType")
	private Condition<OwnerType> ownerTypeCondition;

    /** 集团ID查询条件 */
	@JsonUnwrapped(prefix = "groupId")
	private Condition<String> groupIdCondition;

    /** 商圈ID查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

    /** 商户ID查询条件 */
	@JsonUnwrapped(prefix = "merchantId")
	private Condition<String> merchantIdCondition;

    /** 悦卡面值查询条件 */
	@JsonUnwrapped(prefix = "amount")
	private Condition<BigDecimal> amountCondition;

    /** 悦卡图片地址查询条件 */
	@JsonUnwrapped(prefix = "imgUrl")
	private Condition<String> imgUrlCondition;

    /** 悦卡详情图片地址查询条件 */
	@JsonUnwrapped(prefix = "detailImgUrl")
	private Condition<String> detailImgUrlCondition;

    /** [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件 */
	@JsonUnwrapped(prefix = "timeLimitType")
	private Condition<EntityCardTimeLimitType> timeLimitTypeCondition;

    /** 有效期开始时间 （与有效天数二选一）查询条件 */
	@JsonUnwrapped(prefix = "beginTime")
	private Condition<LocalDate> beginTimeCondition;

    /** 有效期结束时间（与有效天数二选一）查询条件 */
	@JsonUnwrapped(prefix = "endTime")
	private Condition<LocalDate> endTimeCondition;

    /** 有效时长查询条件 */
	@JsonUnwrapped(prefix = "period")
	private Condition<Integer> periodCondition;

    /** [枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件 */
	@JsonUnwrapped(prefix = "periodUnit")
	private Condition<EntityCardPeriodUnit> periodUnitCondition;

    /** 每日限额(-1.00表示不限额）查询条件 */
	@JsonUnwrapped(prefix = "limitAmount")
	private Condition<BigDecimal> limitAmountCondition;

    /** 是否可以退卡查询条件 */
	@JsonUnwrapped(prefix = "canRefund")
	private Condition<Boolean> canRefundCondition;

    /** 退款扣款手续费率比例(0.00~1.00)查询条件 */
	@JsonUnwrapped(prefix = "refundRate")
	private Condition<BigDecimal> refundRateCondition;

    /** 是否收取服务费查询条件 */
	@JsonUnwrapped(prefix = "needServiceFee")
	private Condition<Boolean> needServiceFeeCondition;

    /** [枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件 */
	@JsonUnwrapped(prefix = "scope")
	private Condition<EntityCardScope> scopeCondition;

    /** 悦卡描述查询条件 */
	@JsonUnwrapped(prefix = "description")
	private Condition<String> descriptionCondition;

    /** [枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件 */
	@JsonUnwrapped(prefix = "cardNoRules")
	private Condition<EntityCardCardNoRules> cardNoRulesCondition;

    /** [枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件 */
	@JsonUnwrapped(prefix = "cardPwdRules")
	private Condition<EntityCardCardPwdRules> cardPwdRulesCondition;

    /** [枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件 */
	@JsonUnwrapped(prefix = "makeCardWay")
	private Condition<EntityCardMakeCardWay> makeCardWayCondition;

    /** 制卡数量查询条件 */
	@JsonUnwrapped(prefix = "makeCardNum")
	private Condition<Integer> makeCardNumCondition;

    /** 制卡服务费：手动输入查询条件 */
	@JsonUnwrapped(prefix = "makeCardServiceFee")
	private Condition<BigDecimal> makeCardServiceFeeCondition;

    /** [枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件 */
	@JsonUnwrapped(prefix = "cardStyle")
	private Condition<EntityCardCardStyle> cardStyleCondition;

    /** 卡正面查询条件 */
	@JsonUnwrapped(prefix = "cardPositiveUrl")
	private Condition<String> cardPositiveUrlCondition;

    /** 卡反面查询条件 */
	@JsonUnwrapped(prefix = "cardReverseUrl")
	private Condition<String> cardReverseUrlCondition;

    /** 备注查询条件 */
	@JsonUnwrapped(prefix = "remark")
	private Condition<String> remarkCondition;

    /** 排序查询条件 */
	@JsonUnwrapped(prefix = "sort")
	private Condition<Integer> sortCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "createdBy")
	private Condition<String> createdByCondition;

    /** 创建人名称查询条件 */
	@JsonUnwrapped(prefix = "createdByName")
	private Condition<String> createdByNameCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "createdTime")
	private Condition<LocalDateTime> createdTimeCondition;

    /** 逻辑删除，1表示已删除,0表示未删除查询条件 */
	@JsonUnwrapped(prefix = "del")
	private Condition<Boolean> delCondition;

    /** 删除人ID查询条件 */
	@JsonUnwrapped(prefix = "delBy")
	private Condition<String> delByCondition;

    /** 删除时间查询条件 */
	@JsonUnwrapped(prefix = "delTime")
	private Condition<LocalDateTime> delTimeCondition;

    /** [枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件 */
	@JsonUnwrapped(prefix = "checkStatus")
	private Condition<EntityCardCheckStatus> checkStatusCondition;

    /** 审核人查询条件 */
	@JsonUnwrapped(prefix = "checkBy")
	private Condition<Long> checkByCondition;

    /** 审核名称查询条件 */
	@JsonUnwrapped(prefix = "checkName")
	private Condition<String> checkNameCondition;

    /** 审核时间查询条件 */
	@JsonUnwrapped(prefix = "checkTime")
	private Condition<LocalDateTime> checkTimeCondition;

    /** 审核备注查询条件 */
	@JsonUnwrapped(prefix = "checkRemark")
	private Condition<String> checkRemarkCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public EntityCardQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 * 
	 * @param entity 实体对象
	 */
	public EntityCardQuery(EntityCardEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 * 
	 * @param other 查询条件对象
	 */
	public EntityCardQuery(EntityCardQuery other) {
		super(other);
		if(other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if(other.cardTemplateIdCondition != null) {
			this.cardTemplateIdCondition = other.cardTemplateIdCondition.copy();
		}
		if(other.cardTemplateTitleCondition != null) {
			this.cardTemplateTitleCondition = other.cardTemplateTitleCondition.copy();
		}
		if(other.ownerTypeCondition != null) {
			this.ownerTypeCondition = other.ownerTypeCondition.copy();
		}
		if(other.groupIdCondition != null) {
			this.groupIdCondition = other.groupIdCondition.copy();
		}
		if(other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if(other.merchantIdCondition != null) {
			this.merchantIdCondition = other.merchantIdCondition.copy();
		}
		if(other.amountCondition != null) {
			this.amountCondition = other.amountCondition.copy();
		}
		if(other.imgUrlCondition != null) {
			this.imgUrlCondition = other.imgUrlCondition.copy();
		}
		if(other.detailImgUrlCondition != null) {
			this.detailImgUrlCondition = other.detailImgUrlCondition.copy();
		}
		if(other.timeLimitTypeCondition != null) {
			this.timeLimitTypeCondition = other.timeLimitTypeCondition.copy();
		}
		if(other.beginTimeCondition != null) {
			this.beginTimeCondition = other.beginTimeCondition.copy();
		}
		if(other.endTimeCondition != null) {
			this.endTimeCondition = other.endTimeCondition.copy();
		}
		if(other.periodCondition != null) {
			this.periodCondition = other.periodCondition.copy();
		}
		this.setOther(other);
	}
	private void setOther(EntityCardQuery other){
		if(other.periodUnitCondition != null) {
			this.periodUnitCondition = other.periodUnitCondition.copy();
		}
		if(other.limitAmountCondition != null) {
			this.limitAmountCondition = other.limitAmountCondition.copy();
		}
		if(other.canRefundCondition != null) {
			this.canRefundCondition = other.canRefundCondition.copy();
		}
		if(other.refundRateCondition != null) {
			this.refundRateCondition = other.refundRateCondition.copy();
		}
		if(other.needServiceFeeCondition != null) {
			this.needServiceFeeCondition = other.needServiceFeeCondition.copy();
		}
		if(other.scopeCondition != null) {
			this.scopeCondition = other.scopeCondition.copy();
		}
		if(other.descriptionCondition != null) {
			this.descriptionCondition = other.descriptionCondition.copy();
		}
		if(other.cardNoRulesCondition != null) {
			this.cardNoRulesCondition = other.cardNoRulesCondition.copy();
		}
		if(other.cardPwdRulesCondition != null) {
			this.cardPwdRulesCondition = other.cardPwdRulesCondition.copy();
		}
		if(other.makeCardWayCondition != null) {
			this.makeCardWayCondition = other.makeCardWayCondition.copy();
		}
		if(other.makeCardNumCondition != null) {
			this.makeCardNumCondition = other.makeCardNumCondition.copy();
		}
		if(other.makeCardServiceFeeCondition != null) {
			this.makeCardServiceFeeCondition = other.makeCardServiceFeeCondition.copy();
		}
		if(other.cardStyleCondition != null) {
			this.cardStyleCondition = other.cardStyleCondition.copy();
		}
		if(other.cardPositiveUrlCondition != null) {
			this.cardPositiveUrlCondition = other.cardPositiveUrlCondition.copy();
		}
		this.setOther2(other);
	}
	private void setOther2(EntityCardQuery other){
		if(other.cardReverseUrlCondition != null) {
			this.cardReverseUrlCondition = other.cardReverseUrlCondition.copy();
		}
		if(other.remarkCondition != null) {
			this.remarkCondition = other.remarkCondition.copy();
		}
		if(other.sortCondition != null) {
			this.sortCondition = other.sortCondition.copy();
		}
		if(other.createdByCondition != null) {
			this.createdByCondition = other.createdByCondition.copy();
		}
		if(other.createdByNameCondition != null) {
			this.createdByNameCondition = other.createdByNameCondition.copy();
		}
		if(other.createdTimeCondition != null) {
			this.createdTimeCondition = other.createdTimeCondition.copy();
		}
		if(other.delCondition != null) {
			this.delCondition = other.delCondition.copy();
		}
		if(other.delByCondition != null) {
			this.delByCondition = other.delByCondition.copy();
		}
		if(other.delTimeCondition != null) {
			this.delTimeCondition = other.delTimeCondition.copy();
		}
		if(other.checkStatusCondition != null) {
			this.checkStatusCondition = other.checkStatusCondition.copy();
		}
		if(other.checkByCondition != null) {
			this.checkByCondition = other.checkByCondition.copy();
		}
		if(other.checkNameCondition != null) {
			this.checkNameCondition = other.checkNameCondition.copy();
		}
		if(other.checkTimeCondition != null) {
			this.checkTimeCondition = other.checkTimeCondition.copy();
		}
		if(other.checkRemarkCondition != null) {
			this.checkRemarkCondition = other.checkRemarkCondition.copy();
		}
	}

	@Override
	public QueryWrapper<EntityCardEntity> toQueryWrapper() {
		QueryWrapper<EntityCardEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (cardTemplateIdCondition != null) {
			cardTemplateIdCondition.toWrapper(wrapper, COL_CARD_TEMPLATE_ID);
		}
		if (cardTemplateTitleCondition != null) {
			cardTemplateTitleCondition.toWrapper(wrapper, COL_CARD_TEMPLATE_TITLE);
		}
		if (ownerTypeCondition != null) {
			ownerTypeCondition.toWrapper(wrapper, COL_OWNER_TYPE);
		}
		if (groupIdCondition != null) {
			groupIdCondition.toWrapper(wrapper, COL_GROUP_ID);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (merchantIdCondition != null) {
			merchantIdCondition.toWrapper(wrapper, COL_MERCHANT_ID);
		}
		if (amountCondition != null) {
			amountCondition.toWrapper(wrapper, COL_AMOUNT);
		}
		if (imgUrlCondition != null) {
			imgUrlCondition.toWrapper(wrapper, COL_IMG_URL);
		}
		if (detailImgUrlCondition != null) {
			detailImgUrlCondition.toWrapper(wrapper, COL_DETAIL_IMG_URL);
		}
		if (timeLimitTypeCondition != null) {
			timeLimitTypeCondition.toWrapper(wrapper, COL_TIME_LIMIT_TYPE);
		}
		if (beginTimeCondition != null) {
			beginTimeCondition.toWrapper(wrapper, COL_BEGIN_TIME);
		}
		if (endTimeCondition != null) {
			endTimeCondition.toWrapper(wrapper, COL_END_TIME);
		}
		if (periodCondition != null) {
			periodCondition.toWrapper(wrapper, COL_PERIOD);
		}
		return getQueryWrapper(wrapper);
	}
	private QueryWrapper<EntityCardEntity> getQueryWrapper(QueryWrapper<EntityCardEntity> wrapper){
		if (periodUnitCondition != null) {
			periodUnitCondition.toWrapper(wrapper, COL_PERIOD_UNIT);
		}
		if (limitAmountCondition != null) {
			limitAmountCondition.toWrapper(wrapper, COL_LIMIT_AMOUNT);
		}
		if (canRefundCondition != null) {
			canRefundCondition.toWrapper(wrapper, COL_CAN_REFUND);
		}
		if (refundRateCondition != null) {
			refundRateCondition.toWrapper(wrapper, COL_REFUND_RATE);
		}
		if (needServiceFeeCondition != null) {
			needServiceFeeCondition.toWrapper(wrapper, COL_NEED_SERVICE_FEE);
		}
		if (scopeCondition != null) {
			scopeCondition.toWrapper(wrapper, COL_SCOPE);
		}
		if (descriptionCondition != null) {
			descriptionCondition.toWrapper(wrapper, COL_DESCRIPTION);
		}
		if (cardNoRulesCondition != null) {
			cardNoRulesCondition.toWrapper(wrapper, COL_CARD_NO_RULES);
		}
		if (cardPwdRulesCondition != null) {
			cardPwdRulesCondition.toWrapper(wrapper, COL_CARD_PWD_RULES);
		}
		if (makeCardWayCondition != null) {
			makeCardWayCondition.toWrapper(wrapper, COL_MAKE_CARD_WAY);
		}
		if (makeCardNumCondition != null) {
			makeCardNumCondition.toWrapper(wrapper, COL_MAKE_CARD_NUM);
		}
		if (makeCardServiceFeeCondition != null) {
			makeCardServiceFeeCondition.toWrapper(wrapper, COL_MAKE_CARD_SERVICE_FEE);
		}
		if (cardStyleCondition != null) {
			cardStyleCondition.toWrapper(wrapper, COL_CARD_STYLE);
		}
		if (cardPositiveUrlCondition != null) {
			cardPositiveUrlCondition.toWrapper(wrapper, COL_CARD_POSITIVE_URL);
		}
		return getQueryWrapper2(wrapper);
	}
	private QueryWrapper<EntityCardEntity> getQueryWrapper2(QueryWrapper<EntityCardEntity> wrapper){
		if (cardReverseUrlCondition != null) {
			cardReverseUrlCondition.toWrapper(wrapper, COL_CARD_REVERSE_URL);
		}
		if (remarkCondition != null) {
			remarkCondition.toWrapper(wrapper, COL_REMARK);
		}
		if (sortCondition != null) {
			sortCondition.toWrapper(wrapper, COL_SORT);
		}
		if (createdByCondition != null) {
			createdByCondition.toWrapper(wrapper, COL_CREATED_BY);
		}
		if (createdByNameCondition != null) {
			createdByNameCondition.toWrapper(wrapper, COL_CREATED_BY_NAME);
		}
		if (createdTimeCondition != null) {
			createdTimeCondition.toWrapper(wrapper, COL_CREATED_TIME);
		}
		if (delCondition != null) {
			delCondition.toWrapper(wrapper, COL_DEL);
		}
		if (delByCondition != null) {
			delByCondition.toWrapper(wrapper, COL_DEL_BY);
		}
		if (delTimeCondition != null) {
			delTimeCondition.toWrapper(wrapper, COL_DEL_TIME);
		}
		if (checkStatusCondition != null) {
			checkStatusCondition.toWrapper(wrapper, COL_CHECK_STATUS);
		}
		if (checkByCondition != null) {
			checkByCondition.toWrapper(wrapper, COL_CHECK_BY);
		}
		if (checkNameCondition != null) {
			checkNameCondition.toWrapper(wrapper, COL_CHECK_NAME);
		}
		if (checkTimeCondition != null) {
			checkTimeCondition.toWrapper(wrapper, COL_CHECK_TIME);
		}
		if (checkRemarkCondition != null) {
			checkRemarkCondition.toWrapper(wrapper, COL_CHECK_REMARK);
		}
		return wrapper;
	}

	/**
	 * 构造并返回id查询条件
	 * 
	 * @return idCondition id查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}
	
	/**
	 * 获取id查询条件
	 * 
	 * @return idCondition id查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置id查询条件
	 * 
	 * @param idCondition id查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回悦卡id查询条件
	 * 
	 * @return cardTemplateIdCondition 悦卡id查询条件
	 */
	public Condition<String> cardTemplateId() {
		this.cardTemplateIdCondition = new Condition<>();
		return this.cardTemplateIdCondition;
	}
	
	/**
	 * 获取悦卡id查询条件
	 * 
	 * @return cardTemplateIdCondition 悦卡id查询条件
	 */
	public Condition<String> getCardTemplateIdCondition() {
		return cardTemplateIdCondition;
	}

	/**
	 * 设置悦卡id查询条件
	 * 
	 * @param cardTemplateIdCondition 悦卡id查询条件
	 */
	public void setCardTemplateIdCondition(Condition<String> cardTemplateIdCondition) {
		this.cardTemplateIdCondition = cardTemplateIdCondition;
	}

	/**
	 * 构造并返回悦卡名称查询条件
	 * 
	 * @return cardTemplateTitleCondition 悦卡名称查询条件
	 */
	public Condition<String> cardTemplateTitle() {
		this.cardTemplateTitleCondition = new Condition<>();
		return this.cardTemplateTitleCondition;
	}
	
	/**
	 * 获取悦卡名称查询条件
	 * 
	 * @return cardTemplateTitleCondition 悦卡名称查询条件
	 */
	public Condition<String> getCardTemplateTitleCondition() {
		return cardTemplateTitleCondition;
	}

	/**
	 * 设置悦卡名称查询条件
	 * 
	 * @param cardTemplateTitleCondition 悦卡名称查询条件
	 */
	public void setCardTemplateTitleCondition(Condition<String> cardTemplateTitleCondition) {
		this.cardTemplateTitleCondition = cardTemplateTitleCondition;
	}

	/**
	 * 构造并返回[全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @return ownerTypeCondition [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public Condition<OwnerType> ownerType() {
		this.ownerTypeCondition = new Condition<>();
		return this.ownerTypeCondition;
	}
	
	/**
	 * 获取[全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @return ownerTypeCondition [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public Condition<OwnerType> getOwnerTypeCondition() {
		return ownerTypeCondition;
	}

	/**
	 * 设置[全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 * 
	 * @param ownerTypeCondition [全局枚举]所有者类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSINESS_DISTRICT、3-商户-MERCHANT查询条件
	 */
	public void setOwnerTypeCondition(Condition<OwnerType> ownerTypeCondition) {
		this.ownerTypeCondition = ownerTypeCondition;
	}

	/**
	 * 构造并返回集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> groupId() {
		this.groupIdCondition = new Condition<>();
		return this.groupIdCondition;
	}
	
	/**
	 * 获取集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> getGroupIdCondition() {
		return groupIdCondition;
	}

	/**
	 * 设置集团ID查询条件
	 * 
	 * @param groupIdCondition 集团ID查询条件
	 */
	public void setGroupIdCondition(Condition<String> groupIdCondition) {
		this.groupIdCondition = groupIdCondition;
	}

	/**
	 * 构造并返回商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}
	
	/**
	 * 获取商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈ID查询条件
	 * 
	 * @param busdIdCondition 商圈ID查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回商户ID查询条件
	 * 
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> merchantId() {
		this.merchantIdCondition = new Condition<>();
		return this.merchantIdCondition;
	}
	
	/**
	 * 获取商户ID查询条件
	 * 
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> getMerchantIdCondition() {
		return merchantIdCondition;
	}

	/**
	 * 设置商户ID查询条件
	 * 
	 * @param merchantIdCondition 商户ID查询条件
	 */
	public void setMerchantIdCondition(Condition<String> merchantIdCondition) {
		this.merchantIdCondition = merchantIdCondition;
	}

	/**
	 * 构造并返回悦卡面值查询条件
	 * 
	 * @return amountCondition 悦卡面值查询条件
	 */
	public Condition<BigDecimal> amount() {
		this.amountCondition = new Condition<>();
		return this.amountCondition;
	}
	
	/**
	 * 获取悦卡面值查询条件
	 * 
	 * @return amountCondition 悦卡面值查询条件
	 */
	public Condition<BigDecimal> getAmountCondition() {
		return amountCondition;
	}

	/**
	 * 设置悦卡面值查询条件
	 * 
	 * @param amountCondition 悦卡面值查询条件
	 */
	public void setAmountCondition(Condition<BigDecimal> amountCondition) {
		this.amountCondition = amountCondition;
	}

	/**
	 * 构造并返回悦卡图片地址查询条件
	 * 
	 * @return imgUrlCondition 悦卡图片地址查询条件
	 */
	public Condition<String> imgUrl() {
		this.imgUrlCondition = new Condition<>();
		return this.imgUrlCondition;
	}
	
	/**
	 * 获取悦卡图片地址查询条件
	 * 
	 * @return imgUrlCondition 悦卡图片地址查询条件
	 */
	public Condition<String> getImgUrlCondition() {
		return imgUrlCondition;
	}

	/**
	 * 设置悦卡图片地址查询条件
	 * 
	 * @param imgUrlCondition 悦卡图片地址查询条件
	 */
	public void setImgUrlCondition(Condition<String> imgUrlCondition) {
		this.imgUrlCondition = imgUrlCondition;
	}

	/**
	 * 构造并返回悦卡详情图片地址查询条件
	 * 
	 * @return detailImgUrlCondition 悦卡详情图片地址查询条件
	 */
	public Condition<String> detailImgUrl() {
		this.detailImgUrlCondition = new Condition<>();
		return this.detailImgUrlCondition;
	}
	
	/**
	 * 获取悦卡详情图片地址查询条件
	 * 
	 * @return detailImgUrlCondition 悦卡详情图片地址查询条件
	 */
	public Condition<String> getDetailImgUrlCondition() {
		return detailImgUrlCondition;
	}

	/**
	 * 设置悦卡详情图片地址查询条件
	 * 
	 * @param detailImgUrlCondition 悦卡详情图片地址查询条件
	 */
	public void setDetailImgUrlCondition(Condition<String> detailImgUrlCondition) {
		this.detailImgUrlCondition = detailImgUrlCondition;
	}

	/**
	 * 构造并返回[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件
	 * 
	 * @return timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件
	 */
	public Condition<EntityCardTimeLimitType> timeLimitType() {
		this.timeLimitTypeCondition = new Condition<>();
		return this.timeLimitTypeCondition;
	}
	
	/**
	 * 获取[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件
	 * 
	 * @return timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件
	 */
	public Condition<EntityCardTimeLimitType> getTimeLimitTypeCondition() {
		return timeLimitTypeCondition;
	}

	/**
	 * 设置[枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件
	 * 
	 * @param timeLimitTypeCondition [枚举]时间限制类型：0-固定时段-FIXED_RANGE、1-有效时长-PERIOD查询条件
	 */
	public void setTimeLimitTypeCondition(Condition<EntityCardTimeLimitType> timeLimitTypeCondition) {
		this.timeLimitTypeCondition = timeLimitTypeCondition;
	}

	/**
	 * 构造并返回有效期开始时间 （与有效天数二选一）查询条件
	 * 
	 * @return beginTimeCondition 有效期开始时间 （与有效天数二选一）查询条件
	 */
	public Condition<LocalDate> beginTime() {
		this.beginTimeCondition = new Condition<>();
		return this.beginTimeCondition;
	}
	
	/**
	 * 获取有效期开始时间 （与有效天数二选一）查询条件
	 * 
	 * @return beginTimeCondition 有效期开始时间 （与有效天数二选一）查询条件
	 */
	public Condition<LocalDate> getBeginTimeCondition() {
		return beginTimeCondition;
	}

	/**
	 * 设置有效期开始时间 （与有效天数二选一）查询条件
	 * 
	 * @param beginTimeCondition 有效期开始时间 （与有效天数二选一）查询条件
	 */
	public void setBeginTimeCondition(Condition<LocalDate> beginTimeCondition) {
		this.beginTimeCondition = beginTimeCondition;
	}

	/**
	 * 构造并返回有效期结束时间（与有效天数二选一）查询条件
	 * 
	 * @return endTimeCondition 有效期结束时间（与有效天数二选一）查询条件
	 */
	public Condition<LocalDate> endTime() {
		this.endTimeCondition = new Condition<>();
		return this.endTimeCondition;
	}
	
	/**
	 * 获取有效期结束时间（与有效天数二选一）查询条件
	 * 
	 * @return endTimeCondition 有效期结束时间（与有效天数二选一）查询条件
	 */
	public Condition<LocalDate> getEndTimeCondition() {
		return endTimeCondition;
	}

	/**
	 * 设置有效期结束时间（与有效天数二选一）查询条件
	 * 
	 * @param endTimeCondition 有效期结束时间（与有效天数二选一）查询条件
	 */
	public void setEndTimeCondition(Condition<LocalDate> endTimeCondition) {
		this.endTimeCondition = endTimeCondition;
	}

	/**
	 * 构造并返回有效时长查询条件
	 * 
	 * @return periodCondition 有效时长查询条件
	 */
	public Condition<Integer> period() {
		this.periodCondition = new Condition<>();
		return this.periodCondition;
	}
	
	/**
	 * 获取有效时长查询条件
	 * 
	 * @return periodCondition 有效时长查询条件
	 */
	public Condition<Integer> getPeriodCondition() {
		return periodCondition;
	}

	/**
	 * 设置有效时长查询条件
	 * 
	 * @param periodCondition 有效时长查询条件
	 */
	public void setPeriodCondition(Condition<Integer> periodCondition) {
		this.periodCondition = periodCondition;
	}

	/**
	 * 构造并返回[枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件
	 * 
	 * @return periodUnitCondition [枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件
	 */
	public Condition<EntityCardPeriodUnit> periodUnit() {
		this.periodUnitCondition = new Condition<>();
		return this.periodUnitCondition;
	}
	
	/**
	 * 获取[枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件
	 * 
	 * @return periodUnitCondition [枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件
	 */
	public Condition<EntityCardPeriodUnit> getPeriodUnitCondition() {
		return periodUnitCondition;
	}

	/**
	 * 设置[枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件
	 * 
	 * @param periodUnitCondition [枚举]时长单位：0-分钟-MINUTE、1-小时-HOUR、2-天-DAY、3-月-MONTH、4-年-YEAR查询条件
	 */
	public void setPeriodUnitCondition(Condition<EntityCardPeriodUnit> periodUnitCondition) {
		this.periodUnitCondition = periodUnitCondition;
	}

	/**
	 * 构造并返回每日限额(-1.00表示不限额）查询条件
	 * 
	 * @return limitAmountCondition 每日限额(-1.00表示不限额）查询条件
	 */
	public Condition<BigDecimal> limitAmount() {
		this.limitAmountCondition = new Condition<>();
		return this.limitAmountCondition;
	}
	
	/**
	 * 获取每日限额(-1.00表示不限额）查询条件
	 * 
	 * @return limitAmountCondition 每日限额(-1.00表示不限额）查询条件
	 */
	public Condition<BigDecimal> getLimitAmountCondition() {
		return limitAmountCondition;
	}

	/**
	 * 设置每日限额(-1.00表示不限额）查询条件
	 * 
	 * @param limitAmountCondition 每日限额(-1.00表示不限额）查询条件
	 */
	public void setLimitAmountCondition(Condition<BigDecimal> limitAmountCondition) {
		this.limitAmountCondition = limitAmountCondition;
	}

	/**
	 * 构造并返回是否可以退卡查询条件
	 * 
	 * @return canRefundCondition 是否可以退卡查询条件
	 */
	public Condition<Boolean> canRefund() {
		this.canRefundCondition = new Condition<>();
		return this.canRefundCondition;
	}
	
	/**
	 * 获取是否可以退卡查询条件
	 * 
	 * @return canRefundCondition 是否可以退卡查询条件
	 */
	public Condition<Boolean> getCanRefundCondition() {
		return canRefundCondition;
	}

	/**
	 * 设置是否可以退卡查询条件
	 * 
	 * @param canRefundCondition 是否可以退卡查询条件
	 */
	public void setCanRefundCondition(Condition<Boolean> canRefundCondition) {
		this.canRefundCondition = canRefundCondition;
	}

	/**
	 * 构造并返回退款扣款手续费率比例(0.00~1.00)查询条件
	 * 
	 * @return refundRateCondition 退款扣款手续费率比例(0.00~1.00)查询条件
	 */
	public Condition<BigDecimal> refundRate() {
		this.refundRateCondition = new Condition<>();
		return this.refundRateCondition;
	}
	
	/**
	 * 获取退款扣款手续费率比例(0.00~1.00)查询条件
	 * 
	 * @return refundRateCondition 退款扣款手续费率比例(0.00~1.00)查询条件
	 */
	public Condition<BigDecimal> getRefundRateCondition() {
		return refundRateCondition;
	}

	/**
	 * 设置退款扣款手续费率比例(0.00~1.00)查询条件
	 * 
	 * @param refundRateCondition 退款扣款手续费率比例(0.00~1.00)查询条件
	 */
	public void setRefundRateCondition(Condition<BigDecimal> refundRateCondition) {
		this.refundRateCondition = refundRateCondition;
	}

	/**
	 * 构造并返回是否收取服务费查询条件
	 * 
	 * @return needServiceFeeCondition 是否收取服务费查询条件
	 */
	public Condition<Boolean> needServiceFee() {
		this.needServiceFeeCondition = new Condition<>();
		return this.needServiceFeeCondition;
	}
	
	/**
	 * 获取是否收取服务费查询条件
	 * 
	 * @return needServiceFeeCondition 是否收取服务费查询条件
	 */
	public Condition<Boolean> getNeedServiceFeeCondition() {
		return needServiceFeeCondition;
	}

	/**
	 * 设置是否收取服务费查询条件
	 * 
	 * @param needServiceFeeCondition 是否收取服务费查询条件
	 */
	public void setNeedServiceFeeCondition(Condition<Boolean> needServiceFeeCondition) {
		this.needServiceFeeCondition = needServiceFeeCondition;
	}

	/**
	 * 构造并返回[枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件
	 * 
	 * @return scopeCondition [枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件
	 */
	public Condition<EntityCardScope> scope() {
		this.scopeCondition = new Condition<>();
		return this.scopeCondition;
	}
	
	/**
	 * 获取[枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件
	 * 
	 * @return scopeCondition [枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件
	 */
	public Condition<EntityCardScope> getScopeCondition() {
		return scopeCondition;
	}

	/**
	 * 设置[枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件
	 * 
	 * @param scopeCondition [枚举]使用范围：0-全部-ALL、1-商圈-BUSINESS_DISTRICT、2-商户-MERCHANT查询条件
	 */
	public void setScopeCondition(Condition<EntityCardScope> scopeCondition) {
		this.scopeCondition = scopeCondition;
	}

	/**
	 * 构造并返回悦卡描述查询条件
	 * 
	 * @return descriptionCondition 悦卡描述查询条件
	 */
	public Condition<String> description() {
		this.descriptionCondition = new Condition<>();
		return this.descriptionCondition;
	}
	
	/**
	 * 获取悦卡描述查询条件
	 * 
	 * @return descriptionCondition 悦卡描述查询条件
	 */
	public Condition<String> getDescriptionCondition() {
		return descriptionCondition;
	}

	/**
	 * 设置悦卡描述查询条件
	 * 
	 * @param descriptionCondition 悦卡描述查询条件
	 */
	public void setDescriptionCondition(Condition<String> descriptionCondition) {
		this.descriptionCondition = descriptionCondition;
	}

	/**
	 * 构造并返回[枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件
	 * 
	 * @return cardNoRulesCondition [枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件
	 */
	public Condition<EntityCardCardNoRules> cardNoRules() {
		this.cardNoRulesCondition = new Condition<>();
		return this.cardNoRulesCondition;
	}
	
	/**
	 * 获取[枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件
	 * 
	 * @return cardNoRulesCondition [枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件
	 */
	public Condition<EntityCardCardNoRules> getCardNoRulesCondition() {
		return cardNoRulesCondition;
	}

	/**
	 * 设置[枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件
	 * 
	 * @param cardNoRulesCondition [枚举]卡号规则：12-12位-TWELVE、13-13位-THIRTEEN、14-14位-FOURTEEN、15-15位-FIFTEEN、16-16位-SIXTEEN查询条件
	 */
	public void setCardNoRulesCondition(Condition<EntityCardCardNoRules> cardNoRulesCondition) {
		this.cardNoRulesCondition = cardNoRulesCondition;
	}

	/**
	 * 构造并返回[枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件
	 * 
	 * @return cardPwdRulesCondition [枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件
	 */
	public Condition<EntityCardCardPwdRules> cardPwdRules() {
		this.cardPwdRulesCondition = new Condition<>();
		return this.cardPwdRulesCondition;
	}
	
	/**
	 * 获取[枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件
	 * 
	 * @return cardPwdRulesCondition [枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件
	 */
	public Condition<EntityCardCardPwdRules> getCardPwdRulesCondition() {
		return cardPwdRulesCondition;
	}

	/**
	 * 设置[枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件
	 * 
	 * @param cardPwdRulesCondition [枚举]卡密码规则：6-6位-SIX、7-7位-SEVEN、8-8位-EIGHT查询条件
	 */
	public void setCardPwdRulesCondition(Condition<EntityCardCardPwdRules> cardPwdRulesCondition) {
		this.cardPwdRulesCondition = cardPwdRulesCondition;
	}

	/**
	 * 构造并返回[枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件
	 * 
	 * @return makeCardWayCondition [枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件
	 */
	public Condition<EntityCardMakeCardWay> makeCardWay() {
		this.makeCardWayCondition = new Condition<>();
		return this.makeCardWayCondition;
	}
	
	/**
	 * 获取[枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件
	 * 
	 * @return makeCardWayCondition [枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件
	 */
	public Condition<EntityCardMakeCardWay> getMakeCardWayCondition() {
		return makeCardWayCondition;
	}

	/**
	 * 设置[枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件
	 * 
	 * @param makeCardWayCondition [枚举]制卡方式：0-平台制卡-PLATFORM、1-自己制卡-ONESELF查询条件
	 */
	public void setMakeCardWayCondition(Condition<EntityCardMakeCardWay> makeCardWayCondition) {
		this.makeCardWayCondition = makeCardWayCondition;
	}

	/**
	 * 构造并返回制卡数量查询条件
	 * 
	 * @return makeCardNumCondition 制卡数量查询条件
	 */
	public Condition<Integer> makeCardNum() {
		this.makeCardNumCondition = new Condition<>();
		return this.makeCardNumCondition;
	}
	
	/**
	 * 获取制卡数量查询条件
	 * 
	 * @return makeCardNumCondition 制卡数量查询条件
	 */
	public Condition<Integer> getMakeCardNumCondition() {
		return makeCardNumCondition;
	}

	/**
	 * 设置制卡数量查询条件
	 * 
	 * @param makeCardNumCondition 制卡数量查询条件
	 */
	public void setMakeCardNumCondition(Condition<Integer> makeCardNumCondition) {
		this.makeCardNumCondition = makeCardNumCondition;
	}

	/**
	 * 构造并返回制卡服务费：手动输入查询条件
	 * 
	 * @return makeCardServiceFeeCondition 制卡服务费：手动输入查询条件
	 */
	public Condition<BigDecimal> makeCardServiceFee() {
		this.makeCardServiceFeeCondition = new Condition<>();
		return this.makeCardServiceFeeCondition;
	}
	
	/**
	 * 获取制卡服务费：手动输入查询条件
	 * 
	 * @return makeCardServiceFeeCondition 制卡服务费：手动输入查询条件
	 */
	public Condition<BigDecimal> getMakeCardServiceFeeCondition() {
		return makeCardServiceFeeCondition;
	}

	/**
	 * 设置制卡服务费：手动输入查询条件
	 * 
	 * @param makeCardServiceFeeCondition 制卡服务费：手动输入查询条件
	 */
	public void setMakeCardServiceFeeCondition(Condition<BigDecimal> makeCardServiceFeeCondition) {
		this.makeCardServiceFeeCondition = makeCardServiceFeeCondition;
	}

	/**
	 * 构造并返回[枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件
	 * 
	 * @return cardStyleCondition [枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件
	 */
	public Condition<EntityCardCardStyle> cardStyle() {
		this.cardStyleCondition = new Condition<>();
		return this.cardStyleCondition;
	}
	
	/**
	 * 获取[枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件
	 * 
	 * @return cardStyleCondition [枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件
	 */
	public Condition<EntityCardCardStyle> getCardStyleCondition() {
		return cardStyleCondition;
	}

	/**
	 * 设置[枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件
	 * 
	 * @param cardStyleCondition [枚举]制卡样式：0-刮刮卡-SCRATCH_CARDS查询条件
	 */
	public void setCardStyleCondition(Condition<EntityCardCardStyle> cardStyleCondition) {
		this.cardStyleCondition = cardStyleCondition;
	}

	/**
	 * 构造并返回卡正面查询条件
	 * 
	 * @return cardPositiveUrlCondition 卡正面查询条件
	 */
	public Condition<String> cardPositiveUrl() {
		this.cardPositiveUrlCondition = new Condition<>();
		return this.cardPositiveUrlCondition;
	}
	
	/**
	 * 获取卡正面查询条件
	 * 
	 * @return cardPositiveUrlCondition 卡正面查询条件
	 */
	public Condition<String> getCardPositiveUrlCondition() {
		return cardPositiveUrlCondition;
	}

	/**
	 * 设置卡正面查询条件
	 * 
	 * @param cardPositiveUrlCondition 卡正面查询条件
	 */
	public void setCardPositiveUrlCondition(Condition<String> cardPositiveUrlCondition) {
		this.cardPositiveUrlCondition = cardPositiveUrlCondition;
	}

	/**
	 * 构造并返回卡反面查询条件
	 * 
	 * @return cardReverseUrlCondition 卡反面查询条件
	 */
	public Condition<String> cardReverseUrl() {
		this.cardReverseUrlCondition = new Condition<>();
		return this.cardReverseUrlCondition;
	}
	
	/**
	 * 获取卡反面查询条件
	 * 
	 * @return cardReverseUrlCondition 卡反面查询条件
	 */
	public Condition<String> getCardReverseUrlCondition() {
		return cardReverseUrlCondition;
	}

	/**
	 * 设置卡反面查询条件
	 * 
	 * @param cardReverseUrlCondition 卡反面查询条件
	 */
	public void setCardReverseUrlCondition(Condition<String> cardReverseUrlCondition) {
		this.cardReverseUrlCondition = cardReverseUrlCondition;
	}

	/**
	 * 构造并返回备注查询条件
	 * 
	 * @return remarkCondition 备注查询条件
	 */
	public Condition<String> remark() {
		this.remarkCondition = new Condition<>();
		return this.remarkCondition;
	}
	
	/**
	 * 获取备注查询条件
	 * 
	 * @return remarkCondition 备注查询条件
	 */
	public Condition<String> getRemarkCondition() {
		return remarkCondition;
	}

	/**
	 * 设置备注查询条件
	 * 
	 * @param remarkCondition 备注查询条件
	 */
	public void setRemarkCondition(Condition<String> remarkCondition) {
		this.remarkCondition = remarkCondition;
	}

	/**
	 * 构造并返回排序查询条件
	 * 
	 * @return sortCondition 排序查询条件
	 */
	public Condition<Integer> sort() {
		this.sortCondition = new Condition<>();
		return this.sortCondition;
	}
	
	/**
	 * 获取排序查询条件
	 * 
	 * @return sortCondition 排序查询条件
	 */
	public Condition<Integer> getSortCondition() {
		return sortCondition;
	}

	/**
	 * 设置排序查询条件
	 * 
	 * @param sortCondition 排序查询条件
	 */
	public void setSortCondition(Condition<Integer> sortCondition) {
		this.sortCondition = sortCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return createdByCondition 查询条件
	 */
	public Condition<String> createdBy() {
		this.createdByCondition = new Condition<>();
		return this.createdByCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return createdByCondition 查询条件
	 */
	public Condition<String> getCreatedByCondition() {
		return createdByCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param createdByCondition 查询条件
	 */
	public void setCreatedByCondition(Condition<String> createdByCondition) {
		this.createdByCondition = createdByCondition;
	}

	/**
	 * 构造并返回创建人名称查询条件
	 * 
	 * @return createdByNameCondition 创建人名称查询条件
	 */
	public Condition<String> createdByName() {
		this.createdByNameCondition = new Condition<>();
		return this.createdByNameCondition;
	}
	
	/**
	 * 获取创建人名称查询条件
	 * 
	 * @return createdByNameCondition 创建人名称查询条件
	 */
	public Condition<String> getCreatedByNameCondition() {
		return createdByNameCondition;
	}

	/**
	 * 设置创建人名称查询条件
	 * 
	 * @param createdByNameCondition 创建人名称查询条件
	 */
	public void setCreatedByNameCondition(Condition<String> createdByNameCondition) {
		this.createdByNameCondition = createdByNameCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return createdTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> createdTime() {
		this.createdTimeCondition = new Condition<>();
		return this.createdTimeCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return createdTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> getCreatedTimeCondition() {
		return createdTimeCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param createdTimeCondition 查询条件
	 */
	public void setCreatedTimeCondition(Condition<LocalDateTime> createdTimeCondition) {
		this.createdTimeCondition = createdTimeCondition;
	}

	/**
	 * 构造并返回逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @return delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public Condition<Boolean> del() {
		this.delCondition = new Condition<>();
		return this.delCondition;
	}
	
	/**
	 * 获取逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @return delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public Condition<Boolean> getDelCondition() {
		return delCondition;
	}

	/**
	 * 设置逻辑删除，1表示已删除,0表示未删除查询条件
	 * 
	 * @param delCondition 逻辑删除，1表示已删除,0表示未删除查询条件
	 */
	public void setDelCondition(Condition<Boolean> delCondition) {
		this.delCondition = delCondition;
	}

	/**
	 * 构造并返回删除人ID查询条件
	 * 
	 * @return delByCondition 删除人ID查询条件
	 */
	public Condition<String> delBy() {
		this.delByCondition = new Condition<>();
		return this.delByCondition;
	}
	
	/**
	 * 获取删除人ID查询条件
	 * 
	 * @return delByCondition 删除人ID查询条件
	 */
	public Condition<String> getDelByCondition() {
		return delByCondition;
	}

	/**
	 * 设置删除人ID查询条件
	 * 
	 * @param delByCondition 删除人ID查询条件
	 */
	public void setDelByCondition(Condition<String> delByCondition) {
		this.delByCondition = delByCondition;
	}

	/**
	 * 构造并返回删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> delTime() {
		this.delTimeCondition = new Condition<>();
		return this.delTimeCondition;
	}
	
	/**
	 * 获取删除时间查询条件
	 * 
	 * @return delTimeCondition 删除时间查询条件
	 */
	public Condition<LocalDateTime> getDelTimeCondition() {
		return delTimeCondition;
	}

	/**
	 * 设置删除时间查询条件
	 * 
	 * @param delTimeCondition 删除时间查询条件
	 */
	public void setDelTimeCondition(Condition<LocalDateTime> delTimeCondition) {
		this.delTimeCondition = delTimeCondition;
	}

	/**
	 * 构造并返回[枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件
	 * 
	 * @return checkStatusCondition [枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件
	 */
	public Condition<EntityCardCheckStatus> checkStatus() {
		this.checkStatusCondition = new Condition<>();
		return this.checkStatusCondition;
	}
	
	/**
	 * 获取[枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件
	 * 
	 * @return checkStatusCondition [枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件
	 */
	public Condition<EntityCardCheckStatus> getCheckStatusCondition() {
		return checkStatusCondition;
	}

	/**
	 * 设置[枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件
	 * 
	 * @param checkStatusCondition [枚举]审核状态：0-未付款-UNPAY、1-审核中-CHECKING、2-已完成-SUCCESSED、3-已驳回-REJECTED、4-待收货-WAIT_RECEIVING、5-待激活-ACTIVATE、6-废弃-ABANDONED查询条件
	 */
	public void setCheckStatusCondition(Condition<EntityCardCheckStatus> checkStatusCondition) {
		this.checkStatusCondition = checkStatusCondition;
	}

	/**
	 * 构造并返回审核人查询条件
	 * 
	 * @return checkByCondition 审核人查询条件
	 */
	public Condition<Long> checkBy() {
		this.checkByCondition = new Condition<>();
		return this.checkByCondition;
	}
	
	/**
	 * 获取审核人查询条件
	 * 
	 * @return checkByCondition 审核人查询条件
	 */
	public Condition<Long> getCheckByCondition() {
		return checkByCondition;
	}

	/**
	 * 设置审核人查询条件
	 * 
	 * @param checkByCondition 审核人查询条件
	 */
	public void setCheckByCondition(Condition<Long> checkByCondition) {
		this.checkByCondition = checkByCondition;
	}

	/**
	 * 构造并返回审核名称查询条件
	 * 
	 * @return checkNameCondition 审核名称查询条件
	 */
	public Condition<String> checkName() {
		this.checkNameCondition = new Condition<>();
		return this.checkNameCondition;
	}
	
	/**
	 * 获取审核名称查询条件
	 * 
	 * @return checkNameCondition 审核名称查询条件
	 */
	public Condition<String> getCheckNameCondition() {
		return checkNameCondition;
	}

	/**
	 * 设置审核名称查询条件
	 * 
	 * @param checkNameCondition 审核名称查询条件
	 */
	public void setCheckNameCondition(Condition<String> checkNameCondition) {
		this.checkNameCondition = checkNameCondition;
	}

	/**
	 * 构造并返回审核时间查询条件
	 * 
	 * @return checkTimeCondition 审核时间查询条件
	 */
	public Condition<LocalDateTime> checkTime() {
		this.checkTimeCondition = new Condition<>();
		return this.checkTimeCondition;
	}
	
	/**
	 * 获取审核时间查询条件
	 * 
	 * @return checkTimeCondition 审核时间查询条件
	 */
	public Condition<LocalDateTime> getCheckTimeCondition() {
		return checkTimeCondition;
	}

	/**
	 * 设置审核时间查询条件
	 * 
	 * @param checkTimeCondition 审核时间查询条件
	 */
	public void setCheckTimeCondition(Condition<LocalDateTime> checkTimeCondition) {
		this.checkTimeCondition = checkTimeCondition;
	}

	/**
	 * 构造并返回审核备注查询条件
	 * 
	 * @return checkRemarkCondition 审核备注查询条件
	 */
	public Condition<String> checkRemark() {
		this.checkRemarkCondition = new Condition<>();
		return this.checkRemarkCondition;
	}
	
	/**
	 * 获取审核备注查询条件
	 * 
	 * @return checkRemarkCondition 审核备注查询条件
	 */
	public Condition<String> getCheckRemarkCondition() {
		return checkRemarkCondition;
	}

	/**
	 * 设置审核备注查询条件
	 * 
	 * @param checkRemarkCondition 审核备注查询条件
	 */
	public void setCheckRemarkCondition(Condition<String> checkRemarkCondition) {
		this.checkRemarkCondition = checkRemarkCondition;
	}

}
